home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / QuickTime / Programming Stuff / Sample Code / Movie Toolbox / MyMultipleMoviesApp ƒ / BetterFlattenMovie.c next >
Encoding:
C/C++ Source or Header  |  1994-03-14  |  6.1 KB  |  232 lines  |  [TEXT/KAHL]
  1. /*
  2.     File:        BetterFlattenMovie.c
  3.     
  4.     Contains:    Patched version of FlattenMovie/FlattenMovieData.
  5.  
  6.     Written by:    John Wang
  7.  
  8.     Copyright:    © 1994 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.         <1>        03/14/94    JW        Re-Created for Universal Headers.
  13.  
  14.     To Do:
  15.     
  16. */
  17.  
  18. #ifdef THINK_C
  19. #define        applec
  20. #endif
  21.  
  22. #include    <Types.h>
  23. #include    <Memory.h>
  24. #include    <QuickDraw.h>
  25. #include    <Palettes.h>
  26. #include    <QDOffscreen.h>
  27. #include    <Errors.h>
  28. #include    <Fonts.h>
  29. #include    <Dialogs.h>
  30. #include    <Windows.h>
  31. #include    <Menus.h>
  32. #include    <Events.h>
  33. #include    <Desk.h>
  34. #include    <DiskInit.h>
  35. #include    <OSUtils.h>
  36. #include    <Resources.h>
  37. #include    <ToolUtils.h>
  38. #include    <AppleEvents.h>
  39. #include    <EPPC.h>
  40. #include    <GestaltEqu.h>
  41. #include    <Processes.h>
  42. #include    <Balloons.h>
  43. #include    <Aliases.h>
  44. #include    <MixedMode.h>
  45. #include    <Scrap.h>
  46. #include    <LowMem.h>
  47.  
  48. #include    <Movies.h>
  49.  
  50. #include    "BetterFlattenMovie.h"
  51.  
  52. /* ------------------------------------------------------------------------- */
  53.  
  54. pascal void BetterFlattenMovie(Movie theMovie, long movieFlattenFlags, 
  55.             FSSpec *theFile, OSType creator, ScriptCode scriptTag,
  56.             long createMovieFileFlags, short *resId, const StringPtr resName)
  57. {
  58.     Movie        tempMovie;
  59.     short        refNum;
  60.     
  61.     tempMovie = BetterFlattenMovieData(theMovie, movieFlattenFlags, 
  62.             theFile, creator, scriptTag, createMovieFileFlags);
  63.  
  64.     if (tempMovie) {
  65.         if (OpenMovieFile(theFile, &refNum, fsRdWrPerm) == noErr) {
  66.             AddMovieResource( tempMovie, refNum, resId, resName);
  67.             CloseMovieFile(refNum);
  68.         }
  69.         DisposeMovie(tempMovie);
  70.     }
  71. }
  72.  
  73. pascal Movie BetterFlattenMovieData(Movie theMovie, long movieFlattenFlags, 
  74.             FSSpec *theFile, OSType creator, ScriptCode scriptTag,
  75.             long createMovieFileFlags)
  76. {
  77.     long        QTfeature;
  78.     long        readLength, writeLength, newFileSize, origFileSize;
  79.     long        origheader[2];
  80.     long        newheader[2];
  81.     Movie        tempMovie;
  82.     short        destRefNum;
  83.  
  84.     if (Gestalt(gestaltQuickTime, &QTfeature))
  85.         return(0);
  86.     
  87.     //    Do patch only if running QuickTime 1.6.X or less.
  88.     if ((QTfeature >> 16) < 0x170) {
  89.         origheader[0] = 0;
  90.         origheader[1] = 0;
  91.         //    If file exists and the file size is greater than 8, then we can
  92.         //    assume a atom header exists.  We will read this header into
  93.         //    memory so that we can restore it after calling QuickTime's
  94.         //    FlattenMovieData.
  95.         if (FSpOpenDF(theFile, fsRdPerm, &destRefNum) == noErr) {
  96.             if (GetEOF(destRefNum, &origFileSize))
  97.                 return(nil);
  98.             if (origFileSize >= 8) {
  99.                 if (SetFPos(destRefNum, fsFromStart, 0))
  100.                     return(0);
  101.                 readLength = 8;
  102.                 if (FSRead(destRefNum, &readLength, origheader))
  103.                     return(0);
  104.             }
  105.             FSClose(destRefNum);
  106.         }
  107.     }
  108.     
  109.     //    Call QuickTime's FlattenMovieData.
  110.     tempMovie = FlattenMovieData(theMovie, movieFlattenFlags, theFile, creator, scriptTag, createMovieFileFlags);
  111.  
  112.     //    Do patch only if running QuickTime 1.6.X or less.
  113.     if ((QTfeature >> 16) < 0x170) {
  114.         if (FSpOpenDF(theFile, fsWrPerm, &destRefNum) == noErr) {
  115.             //    Get new header which is always stored at offset 0 of data fork.
  116.             newheader[0] = 0;
  117.             newheader[1] = 0;
  118.             if (GetEOF(destRefNum, &newFileSize))
  119.                 return(0);
  120.             if (newFileSize >= 8) {
  121.                 if (SetFPos(destRefNum, fsFromStart, 0))
  122.                     return(0);
  123.                 readLength = 8;
  124.                 if (FSRead(destRefNum, &readLength, newheader))
  125.                     return(0);
  126.             }
  127.             
  128.             //    Write old header back.
  129.             if (newFileSize >= 8) {
  130.                 if (SetFPos(destRefNum, fsFromStart, 0))
  131.                     return(0);
  132.                 writeLength = 8;
  133.                 if (FSWrite(destRefNum, &writeLength, origheader))
  134.                     return(0);
  135.             }
  136.             
  137.             //    Write new header in the right place.
  138.             if (newFileSize > (origFileSize + 8)) {
  139.                 if (SetFPos(destRefNum, fsFromStart, origFileSize))
  140.                     return;
  141.                 //    If newheader size is not 0, then calculate new header size by
  142.                 //        (i) subtracting out the original file size if the newheader size is
  143.                 //            larger than the original file size.
  144.                 //        (ii) subtracting the original filesize fromt the new filesize if
  145.                 //            the header size is less than or equal to the original filesize.
  146.                 //            The reason for this is that FlattenMovieData does not calculate
  147.                 //            a new header size unless the movie atom is written to the data fork.
  148.                 //            Thus, if there is no data fork, then we can assume that the only
  149.                 //            atom added is the movie data atom.
  150.                 //    If newheader size is equal to 0, then probably there is no movie
  151.                 //    atom and the size is simply the size to the end of the file.
  152.                 if (newheader[0] != 0) {
  153.                     if (newheader[0] <= origFileSize)
  154.                         newheader[0] = newFileSize - origFileSize;
  155.                     else
  156.                         newheader[0] = newheader[0] - origFileSize;
  157.                 }  else
  158.                     newheader[0] = newFileSize - origFileSize;
  159.                 writeLength = 8;
  160.                 if (FSWrite(destRefNum, &writeLength, newheader))
  161.                     return;
  162.             }
  163.             FlushVol(nil, theFile->vRefNum);
  164.             FSClose(destRefNum);
  165.         }
  166.     }
  167.     
  168.     return(tempMovie);
  169. }
  170.  
  171. /* ------------------------------------------------------------------------- */
  172.  
  173. OSErr CountMoviesInDataFork(FSSpec *theFile, short *count)
  174. {
  175.     long        header[2];
  176.     short        myRefNum;
  177.     long        fileSize, currentLoc, readLength;
  178.     short        doneCounter;
  179.     OSErr        err;
  180.  
  181.     *count = 0;
  182.     if (FSpOpenDF(theFile, fsRdPerm, &myRefNum) == noErr) {
  183.         if (err = GetEOF(myRefNum, &fileSize))
  184.             return(err);
  185.         currentLoc = 0;
  186.         doneCounter = 0;
  187.         while (fileSize > (currentLoc + 8)) {
  188.             if (err = SetFPos(myRefNum, fsFromStart, currentLoc))
  189.                 return(err);
  190.             readLength = 8;
  191.             if (err = FSRead(myRefNum, &readLength, header))
  192.                 return(err);
  193.             if (header[1] == 'moov')
  194.                 doneCounter++;
  195.             currentLoc += header[0];
  196.         }
  197.         *count = doneCounter;
  198.         FSClose(myRefNum);
  199.     } else
  200.         return(err);
  201.     return(noErr);
  202. }
  203.  
  204. OSErr SearchMoviesInDataFork(FSSpec *theFile, short index, long *fileOffset)
  205. {
  206.     long        header[2];
  207.     short        myRefNum;
  208.     long        currentLoc, readLength;
  209.     short        doneCounter;
  210.     OSErr        err;
  211.  
  212.     if (FSpOpenDF(theFile, fsRdPerm, &myRefNum) == noErr) {
  213.         currentLoc = 0;
  214.         doneCounter = index;
  215.         *fileOffset = 0;
  216.         while ((doneCounter > 0)) {
  217.             if (err = SetFPos(myRefNum, fsFromStart, currentLoc))
  218.                 return(err);
  219.             readLength = 8;
  220.             if (err = FSRead(myRefNum, &readLength, header))
  221.                 return(err);
  222.             if (header[1] == 'moov')
  223.                 doneCounter--;
  224.             *fileOffset = currentLoc;
  225.             currentLoc += header[0];
  226.         }
  227.         FSClose(myRefNum);
  228.     } else
  229.         return(err);
  230.     return(noErr);
  231. }
  232.